home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / wais / waisgate / zprot.c < prev    next >
C/C++ Source or Header  |  1995-05-09  |  32KB  |  1,138 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:`
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.    
  4. /*
  5.  
  6. #ifndef lint
  7. static char *RCSid = "$Header: /tmp_mnt/net/quake/proj/wais/wais-8-b5/ir/RCS/zprot.c,v 1.4 92/02/12 13:59:51 jonathan Exp $";
  8. #endif
  9.  
  10. /* Change log:
  11.  * $Log:    zprot.c,v $
  12.  * Revision 1.4  92/02/12  13:59:51  jonathan
  13.  * Added "$Log" so RCS will put the log message in the header
  14.  * 
  15.  * 
  16.   
  17.    3.26.90    Harry Morris, morris@think.com
  18.    3.30.90  Harry Morris - Changed any->bits to any->bytes
  19.    4.11.90  HWM - generalized conditional includes (see c-dialect.h)
  20. */
  21.  
  22. #define _C_Z39_50_
  23.  
  24. #include "zprot.h"
  25.  
  26. #include "zutil.h"
  27. #include "cutil.h"
  28. #include <string.h>
  29.  
  30. #ifndef ANSI_LIKE
  31. #include "ustubs.h"
  32. #endif
  33.  
  34. #define RESERVE_SPACE_FOR_HEADER(spaceLeft)        \
  35.     *spaceLeft -= HEADER_LEN;
  36.     
  37. #define RELEASE_HEADER_SPACE(spaceLeft)            \
  38.     if (*spaceLeft > 0)                            \
  39.       *spaceLeft += HEADER_LEN;
  40.     
  41. /*----------------------------------------------------------------------*/
  42.  
  43. InitAPDU* 
  44. makeInitAPDU(search,
  45.          present,
  46.          deleteIt,
  47.          accessControl,
  48.          resourceControl,
  49.          prefSize,
  50.          maxMsgSize,
  51.          auth,
  52.          id,
  53.          name,
  54.          version,
  55.          refID,
  56.          userInfo)
  57. boolean search;
  58. boolean present;
  59. boolean deleteIt;
  60. boolean accessControl;
  61. boolean resourceControl;
  62. long prefSize;
  63. long maxMsgSize;
  64. char* auth;
  65. char* id;
  66. char* name;
  67. char* version;
  68. any* refID;
  69. void* userInfo;
  70.  
  71. /* build an init APDU with user specified information */
  72. { 
  73.   InitAPDU* init = (InitAPDU*)s_malloc((size_t)sizeof(InitAPDU));
  74.  
  75.   init->PDUType = initAPDU;
  76.   init->willSearch = search;
  77.   init->willPresent = present;
  78.   init->willDelete = deleteIt;
  79.   init->supportAccessControl = accessControl;
  80.   init->supportResourceControl = resourceControl;
  81.   init->PreferredMessageSize = prefSize;
  82.   init->MaximumRecordSize = maxMsgSize;
  83.   init->IDAuthentication = s_strdup(auth);
  84.   init->ImplementationID = s_strdup(id);
  85.   init->ImplementationName = s_strdup(name);
  86.   init->ImplementationVersion = s_strdup(version);
  87.   init->ReferenceID = duplicateAny(refID);
  88.   init->UserInformationField = userInfo; /* not copied */
  89.   
  90.   return(init);
  91. }
  92.  
  93. /*----------------------------------------------------------------------*/
  94.  
  95. void 
  96. freeInitAPDU(init)
  97. InitAPDU* init;
  98. /* free an initAPDU */
  99. {
  100.   s_free(init->IDAuthentication);
  101.   s_free(init->ImplementationID);
  102.   s_free(init->ImplementationName);
  103.   s_free(init->ImplementationVersion);
  104.   freeAny(init->ReferenceID);
  105.   s_free(init);
  106. }
  107.  
  108. /*----------------------------------------------------------------------*/
  109.  
  110. char* 
  111. writeInitAPDU(init,buffer,len)
  112. InitAPDU* init;
  113. char* buffer;
  114. long* len;
  115. /* write the init to a buffer, adding system information */
  116. {
  117.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  118.   long size;
  119.   bit_map* optionsBM = NULL;
  120.  
  121.   RESERVE_SPACE_FOR_HEADER(len);
  122.   
  123.   buf = writePDUType(init->PDUType,buf,len);
  124.   
  125.   buf = writeProtocolVersion(buf,len);
  126.   
  127.   optionsBM = makeBitMap((unsigned long)5,init->willSearch,init->willPresent,
  128.                          init->willDelete,init->supportAccessControl,
  129.                          init->supportResourceControl);
  130.   buf = writeBitMap(optionsBM,DT_Options,buf,len);
  131.   freeBitMap(optionsBM);
  132.  
  133.   buf = writeNum(init->PreferredMessageSize,DT_PreferredMessageSize,buf,len);
  134.   buf = writeNum(init->MaximumRecordSize,DT_MaximumRecordSize,buf,len);
  135.   buf = writeString(init->IDAuthentication,DT_IDAuthentication,buf,len);
  136.   buf = writeString(init->ImplementationID,DT_ImplementationID,buf,len);
  137.   buf = writeString(init->ImplementationName,DT_ImplementationName,buf,len);
  138.   buf = writeString(init->ImplementationVersion,DT_ImplementationVersion,buf,len);
  139.   buf = writeAny(init->ReferenceID,DT_ReferenceID,buf,len);
  140.   
  141.   /* go back and write the header-length-indicator */
  142.   RELEASE_HEADER_SPACE(len);
  143.   size = buf - buffer - HEADER_LEN; 
  144.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  145.  
  146.   if (init->UserInformationField != NULL)
  147.     buf = writeInitInfo(init,buf,len);   
  148.     
  149.   return(buf); 
  150. }
  151.  
  152. /*----------------------------------------------------------------------*/
  153.  
  154. char* 
  155. readInitAPDU(init,buffer)
  156. InitAPDU** init;
  157. char* buffer;
  158. {
  159.   char* buf = buffer;
  160.   boolean search,present,delete,accessControl,resourceControl;
  161.   long prefSize,maxMsgSize;
  162.   char *auth,*id,*name,*version;
  163.   long size; 
  164.   pdu_type pduType;
  165.   bit_map* versionBM = NULL;
  166.   bit_map* optionsBM = NULL;
  167.   any *refID = NULL;
  168.   void* userInfo = NULL;
  169.   
  170.   auth = id = name = version = NULL;
  171.   
  172.   /* read required part */
  173.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  174.   buf = readPDUType(&pduType,buf);
  175.   buf = readBitMap(&versionBM,buf); 
  176.   buf = readBitMap(&optionsBM,buf);
  177.   buf = readNum(&prefSize,buf);
  178.   buf = readNum(&maxMsgSize,buf);
  179.   
  180.   /* decode optionsBM */
  181.   search = bitAtPos(0L,optionsBM);
  182.   present = bitAtPos(1L,optionsBM);
  183.   delete = bitAtPos(2L,optionsBM);
  184.   accessControl = bitAtPos(3L,optionsBM);
  185.   resourceControl = bitAtPos(4L,optionsBM);
  186.   
  187.   /* read optional part */
  188.   while (buf < (buffer + size + HEADER_LEN)) 
  189.     { data_tag tag = peekTag(buf);
  190.       switch (tag)
  191.     { case DT_IDAuthentication:
  192.         buf = readString(&auth,buf);
  193.         break;
  194.       case DT_ImplementationID:
  195.         buf = readString(&id,buf);
  196.         break;
  197.       case DT_ImplementationName:
  198.         buf = readString(&name,buf);
  199.         break;
  200.       case DT_ImplementationVersion:
  201.         buf = readString(&version,buf);
  202.         break;
  203.       case DT_ReferenceID:
  204.         buf = readAny(&refID,buf);
  205.         break;
  206.       default:
  207.         freeBitMap(versionBM);
  208.         freeBitMap(optionsBM);
  209.         s_free(auth);
  210.         s_free(id);
  211.         s_free(name);
  212.         s_free(version);
  213.         freeAny(refID);
  214.         REPORT_READ_ERROR(buf);
  215.         break;
  216.       }
  217.     }
  218.  
  219.   buf = readInitInfo(&userInfo,buf);
  220.   if (buf == NULL)
  221.     { freeBitMap(versionBM);
  222.       freeBitMap(optionsBM);
  223.       s_free(auth);
  224.       s_free(id);
  225.       s_free(name);
  226.       s_free(version);
  227.       freeAny(refID);
  228.     }
  229.   RETURN_ON_NULL(buf);
  230.  
  231.   /* construct the basic init object */
  232.   *init = makeInitAPDU(search,present,delete,accessControl,resourceControl,
  233.                        prefSize,maxMsgSize,auth,id,name,version,refID,userInfo);
  234.                           
  235.   freeBitMap(versionBM);
  236.   freeBitMap(optionsBM);
  237.   s_free(auth);
  238.   s_free(id);
  239.   s_free(name);
  240.   s_free(version);
  241.   freeAny(refID);
  242.   
  243.   return(buf);
  244. }
  245.  
  246. /*----------------------------------------------------------------------*/
  247.  
  248. InitResponseAPDU* 
  249. makeInitResponseAPDU(result,
  250.              search,
  251.              present,
  252.              deleteIt,
  253.              accessControl,
  254.              resourceControl,
  255.              prefSize,
  256.              maxMsgSize,
  257.              auth,
  258.              id,
  259.              name,
  260.              version,
  261.              refID,
  262.              userInfo)
  263. boolean result;
  264. boolean search;
  265. boolean present;
  266. boolean deleteIt;
  267. boolean accessControl;
  268. boolean resourceControl;
  269. long prefSize;
  270. long maxMsgSize;
  271. char* auth;
  272. char* id;
  273. char* name;
  274. char* version;
  275. any* refID;
  276. void* userInfo;
  277. /* build an initResponse APDU with user specified information */
  278. { 
  279.   InitResponseAPDU* init = (InitResponseAPDU*)s_malloc((size_t)sizeof(InitResponseAPDU));
  280.  
  281.   init->PDUType = initResponseAPDU;
  282.   init->Result = result;
  283.   init->willSearch = search;
  284.   init->willPresent = present;
  285.   init->willDelete = deleteIt;
  286.   init->supportAccessControl = accessControl;
  287.   init->supportResourceControl = resourceControl;
  288.   init->PreferredMessageSize = prefSize;
  289.   init->MaximumRecordSize = maxMsgSize;
  290.   init->IDAuthentication = s_strdup(auth);
  291.   init->ImplementationID = s_strdup(id);
  292.   init->ImplementationName = s_strdup(name);
  293.   init->ImplementationVersion = s_strdup(version);
  294.   init->ReferenceID = duplicateAny(refID);
  295.   init->UserInformationField = userInfo; /* not copied! */
  296.   
  297.   return(init);
  298. }
  299.  
  300. /*----------------------------------------------------------------------*/
  301.  
  302. void 
  303. freeInitResponseAPDU(init)
  304. InitResponseAPDU* init;
  305. /* free an initAPDU */
  306. {
  307.   s_free(init->IDAuthentication);
  308.   s_free(init->ImplementationID);
  309.   s_free(init->ImplementationName);
  310.   s_free(init->ImplementationVersion);
  311.   freeAny(init->ReferenceID);
  312.   s_free(init);
  313. }
  314.  
  315. /*----------------------------------------------------------------------*/
  316.  
  317. char* 
  318. writeInitResponseAPDU(init,buffer,len)
  319. InitResponseAPDU* init;
  320. char* buffer;
  321. long* len;
  322. /* write the initResponse to a buffer, adding system information */
  323. { 
  324.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  325.   long size;
  326.   bit_map* optionsBM = NULL;
  327.  
  328.   RESERVE_SPACE_FOR_HEADER(len);
  329.   
  330.   buf = writePDUType(init->PDUType,buf,len);
  331.   buf = writeBoolean(init->Result,buf,len);
  332.   buf = writeProtocolVersion(buf,len);
  333.   
  334.   optionsBM = makeBitMap((unsigned long)5,init->willSearch,init->willPresent,
  335.                          init->willDelete,init->supportAccessControl,
  336.                          init->supportResourceControl);
  337.   buf = writeBitMap(optionsBM,DT_Options,buf,len);
  338.   freeBitMap(optionsBM);
  339.  
  340.   buf = writeNum(init->PreferredMessageSize,DT_PreferredMessageSize,buf,len);
  341.   buf = writeNum(init->MaximumRecordSize,DT_MaximumRecordSize,buf,len);
  342.   buf = writeString(init->IDAuthentication,DT_IDAuthentication,buf,len);
  343.   buf = writeString(init->ImplementationID,DT_ImplementationID,buf,len);
  344.   buf = writeString(init->ImplementationName,DT_ImplementationName,buf,len);
  345.   buf = writeString(init->ImplementationVersion,DT_ImplementationVersion,buf,len);
  346.   buf = writeAny(init->ReferenceID,DT_ReferenceID,buf,len);
  347.   
  348.   /* go back and write the header-length-indicator */
  349.   RELEASE_HEADER_SPACE(len);
  350.   size = buf - buffer - HEADER_LEN; 
  351.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  352.  
  353.   if (init->UserInformationField != NULL)
  354.     buf = writeInitResponseInfo(init,buf,len);   
  355.     
  356.   return(buf);
  357. }
  358.  
  359. /*----------------------------------------------------------------------*/
  360.  
  361. char* 
  362. readInitResponseAPDU(init,buffer)
  363. InitResponseAPDU** init;
  364. char* buffer;
  365. {
  366.   char* buf = buffer;
  367.   boolean search,present,delete,accessControl,resourceControl;
  368.   long prefSize,maxMsgSize;
  369.   char *auth,*id,*name,*version;
  370.   long size; 
  371.   pdu_type pduType;
  372.   bit_map* versionBM = NULL;
  373.   bit_map* optionsBM = NULL;
  374.   boolean result;
  375.   any *refID = NULL;
  376.   void* userInfo = NULL;
  377.   
  378.   auth = id = name = version = NULL;
  379.   refID = NULL;
  380.   
  381.   /* read required part */
  382.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  383.   buf = readPDUType(&pduType,buf);
  384.   buf = readBoolean(&result,buf);
  385.   buf = readBitMap(&versionBM,buf); 
  386.   buf = readBitMap(&optionsBM,buf);
  387.   buf = readNum(&prefSize,buf);
  388.   buf = readNum(&maxMsgSize,buf);
  389.   
  390.   /* decode optionsBM */
  391.   search = bitAtPos(0L,optionsBM);
  392.   present = bitAtPos(1L,optionsBM);
  393.   delete = bitAtPos(2L,optionsBM);
  394.   accessControl = bitAtPos(3L,optionsBM);
  395.   resourceControl = bitAtPos(4L,optionsBM);
  396.   
  397.   /* read optional part */
  398.   while (buf < (buffer + size + HEADER_LEN)) 
  399.     { data_tag tag = peekTag(buf);
  400.       switch (tag)
  401.     { case DT_IDAuthentication:
  402.         buf = readString(&auth,buf);
  403.         break;
  404.       case DT_ImplementationID:
  405.         buf = readString(&id,buf);
  406.         break;
  407.       case DT_ImplementationName:
  408.         buf = readString(&name,buf);
  409.         break;
  410.       case DT_ImplementationVersion:
  411.         buf = readString(&version,buf);
  412.         break;
  413.       case DT_ReferenceID:
  414.         buf = readAny(&refID,buf);
  415.         break;
  416.       default:
  417.         freeBitMap(versionBM);
  418.         freeBitMap(optionsBM);
  419.         s_free(auth);
  420.         s_free(id);
  421.         s_free(name);
  422.         s_free(version);
  423.         freeAny(refID);
  424.         REPORT_READ_ERROR(buf);
  425.         break;
  426.       }
  427.     }
  428.  
  429.   buf = readInitResponseInfo(&userInfo,buf);
  430.   if (buf == NULL)
  431.     { freeBitMap(versionBM);
  432.       freeBitMap(optionsBM);
  433.       s_free(auth);
  434.       s_free(id);
  435.       s_free(name);
  436.       s_free(version);
  437.       freeAny(refID);
  438.     }
  439.   RETURN_ON_NULL(buf);
  440.   
  441.   /* construct the basic init object */
  442.   *init = makeInitResponseAPDU(result,
  443.                    search,present,delete,accessControl,resourceControl,
  444.                    prefSize,maxMsgSize,auth,id,name,version,refID,userInfo);
  445.                                           
  446.   freeBitMap(versionBM);
  447.   freeBitMap(optionsBM);
  448.   s_free(auth);
  449.   s_free(id);
  450.   s_free(name);
  451.   s_free(version);
  452.   freeAny(refID);
  453.   
  454.   return(buf);
  455. }
  456.  
  457. /*----------------------------------------------------------------------*/
  458.  
  459. InitResponseAPDU* 
  460. replyToInitAPDU(init,result,userInfo)
  461. InitAPDU* init;
  462. boolean result;
  463. void* userInfo;
  464. /* respond to an init message in the default way - echoing back
  465.    the init info 
  466.  */
  467. {
  468.   InitResponseAPDU* initResp;
  469.   initResp = makeInitResponseAPDU(result,
  470.                   init->willSearch,init->willPresent,init->willDelete,
  471.                   init->supportAccessControl,init->supportResourceControl,
  472.                   init->PreferredMessageSize,init->MaximumRecordSize,
  473.                   init->IDAuthentication,defaultImplementationID(),defaultImplementationName(),
  474.                   defaultImplementationVersion(),
  475.                   init->ReferenceID,userInfo);
  476.   return(initResp);
  477. }
  478.  
  479. /*----------------------------------------------------------------------*/
  480.  
  481. SearchAPDU* 
  482. makeSearchAPDU(small,
  483.            large,
  484.            medium,
  485.            replace,
  486.            name,
  487.            databases,
  488.            type,
  489.            elements,
  490.            refID,
  491.            queryInfo)
  492. long small;
  493. long large;
  494. long medium;
  495. boolean replace;
  496. char* name;
  497. char** databases;
  498. char* type;
  499. char** elements;
  500. any* refID;
  501. void* queryInfo;
  502. {
  503.   char* ptr = NULL;
  504.   long i;
  505.   SearchAPDU* query = (SearchAPDU*)s_malloc((size_t)sizeof(SearchAPDU));
  506.   query->PDUType = searchAPDU;
  507.   query->SmallSetUpperBound = small;
  508.   query->LargeSetLowerBound = large;
  509.   query->MediumSetPresentNumber = medium;
  510.   query->ReplaceIndicator = replace;
  511.   query->ResultSetName = s_strdup(name);
  512.   query->DatabaseNames = NULL; 
  513.   if (databases != NULL)
  514.     { for (i = 0, ptr = databases[i]; ptr != NULL; ptr = databases[++i])
  515.     { if (query->DatabaseNames == NULL)
  516.         query->DatabaseNames = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  517.         else
  518.           query->DatabaseNames = (char**)s_realloc((char*)query->DatabaseNames,
  519.                            (size_t)(sizeof(char*) * (i + 2)));
  520.         query->DatabaseNames[i] = s_strdup(ptr);
  521.         query->DatabaseNames[i+1] = NULL;
  522.       }
  523.       }
  524.   query->QueryType = s_strdup(type);
  525.   query->ElementSetNames = NULL; 
  526.   if (elements != NULL)
  527.     { for (i = 0, ptr = elements[i]; ptr != NULL; ptr = elements[++i])
  528.     { if (query->ElementSetNames == NULL)
  529.         query->ElementSetNames = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  530.         else
  531.           query->ElementSetNames = (char**)s_realloc((char*)query->ElementSetNames,
  532.                              (size_t)(sizeof(char*) * (i + 2)));
  533.         query->ElementSetNames[i] = s_strdup(ptr);
  534.         query->ElementSetNames[i+1] = NULL;
  535.       }
  536.       }
  537.   query->ReferenceID = duplicateAny(refID);
  538.   query->Query = queryInfo;    /* not copied! */
  539.   return(query);
  540. }
  541.  
  542. /*----------------------------------------------------------------------*/
  543.  
  544. void 
  545. freeSearchAPDU(query)
  546. SearchAPDU* query;
  547. {
  548.   s_free(query->ResultSetName);
  549.   s_free(query->QueryType);
  550.   doList((void**)query->DatabaseNames,fs_free); /* can't use the macro here ! */
  551.   s_free(query->DatabaseNames);
  552.   doList((void**)query->ElementSetNames,fs_free); /* can't use the macro here ! */
  553.   s_free(query->ElementSetNames);
  554.   freeAny(query->ReferenceID);
  555.   s_free(query);
  556. }
  557.  
  558. /*----------------------------------------------------------------------*/
  559.  
  560. #define DB_DELIMITER     "\037"     /* hex 1F occurs between each database name */
  561. #define ES_DELIMITER_1     "\037"     /* separates database name from element name */
  562. #define ES_DELIMITER_2     "\036"     /* hex 1E separates <db,es> groups from one another */
  563.  
  564. char* 
  565. writeSearchAPDU(query,buffer,len)
  566. SearchAPDU* query;
  567. char* buffer;
  568. long* len;
  569. { 
  570.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  571.   long size,i;
  572.   char* ptr = NULL;
  573.   char* scratch = NULL;
  574.  
  575.   RESERVE_SPACE_FOR_HEADER(len);
  576.   
  577.   buf = writePDUType(query->PDUType,buf,len);
  578.   buf = writeBinaryInteger(query->SmallSetUpperBound,(size_t)3,buf,len);
  579.   buf = writeBinaryInteger(query->LargeSetLowerBound,(size_t)3,buf,len);
  580.   buf = writeBinaryInteger(query->MediumSetPresentNumber,(size_t)3,buf,len);
  581.   buf = writeBoolean(query->ReplaceIndicator,buf,len);
  582.   buf = writeString(query->ResultSetName,DT_ResultSetName,buf,len);
  583.   /* write database names */
  584.   if (query->DatabaseNames != NULL)
  585.     { for (i = 0,scratch = NULL, ptr = query->DatabaseNames[i]; ptr != NULL; ptr = query->DatabaseNames[++i])
  586.     { if (scratch == NULL)
  587.         scratch = s_strdup(ptr);
  588.         else
  589.       { size_t newScratchSize = (size_t)(strlen(scratch) + strlen(ptr) + 3);
  590.         scratch = (char*)s_realloc(scratch,newScratchSize);
  591.         s_strncat(scratch,DB_DELIMITER,2L,newScratchSize);
  592.         s_strncat(scratch,ptr,strlen(ptr) + 1,newScratchSize);
  593.       }
  594.       }
  595.     buf = writeString(scratch,DT_DatabaseNames,buf,len);
  596.     s_free(scratch);
  597.       }
  598.   buf = writeString(query->QueryType,DT_QueryType,buf,len);
  599.   /* write element set names */
  600.   if (query->ElementSetNames != NULL)
  601.     { for (i = 0,scratch = NULL, ptr = query->ElementSetNames[i]; ptr != NULL; ptr = query->ElementSetNames[++i])
  602.     { if (scratch == NULL)
  603.         { if (query->ElementSetNames[i+1] == NULL) /* there is a single element set name */
  604.         { scratch = (char*)s_malloc((size_t)strlen(ptr) + 3);
  605.           strncpy(scratch,ES_DELIMITER_1,2);
  606.           s_strncat(scratch,ptr,strlen(ptr) + 1,strlen(ptr) + 2);
  607.         }
  608.         else        /* this is the first of a series of element set names */
  609.           { size_t newScratchSize = (size_t)(strlen(ptr) + strlen(query->ElementSetNames[i + 1]) + 3);
  610.         scratch = s_strdup(ptr); /* the database name */
  611.         ptr = query->ElementSetNames[++i]; /* the element set name */
  612.         scratch = (char*)s_realloc(scratch,newScratchSize);
  613.         s_strncat(scratch,ES_DELIMITER_1,2L,newScratchSize);
  614.         s_strncat(scratch,ptr,strlen(ptr) + 1,newScratchSize); 
  615.           }
  616.           }
  617.         else
  618.       { char* esPtr = query->ElementSetNames[++i]; /* the element set name */
  619.         size_t newScratchSize = (size_t)(strlen(scratch) + strlen(ptr) + strlen(esPtr) + 3);
  620.         scratch = (char*)s_realloc(scratch,newScratchSize);
  621.         s_strncat(scratch,ES_DELIMITER_2,2L,newScratchSize);
  622.         s_strncat(scratch,ptr,strlen(ptr) + 1,newScratchSize);
  623.         s_strncat(scratch,ES_DELIMITER_1,2L,newScratchSize);
  624.         s_strncat(scratch,esPtr,strlen(esPtr) + 1,newScratchSize); 
  625.       }
  626.       }
  627.     buf = writeString(scratch,DT_ElementSetNames,buf,len);
  628.     s_free(scratch);
  629.       }                        
  630.   buf = writeAny(query->ReferenceID,DT_ReferenceID,buf,len);
  631.     
  632.   /* go back and write the header-length-indicator */
  633.   RELEASE_HEADER_SPACE(len);
  634.   size = buf - buffer - HEADER_LEN; 
  635.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  636.  
  637.   if (query->Query != NULL)
  638.     buf = writeSearchInfo(query,buf,len);    
  639.     
  640.   return(buf);
  641. }
  642.  
  643. /*----------------------------------------------------------------------*/
  644.  
  645. char*
  646. readSearchAPDU(query,buffer)
  647. SearchAPDU** query;
  648. char* buffer;
  649. {
  650.   char* buf = buffer;
  651.   long size;
  652.   pdu_type pduType;
  653.   long small,large,medium,numItems;
  654.   boolean replace;
  655.   char *name,*databaseNames,*type,*elements;
  656.   char **dbList,**elemList;
  657.   any *refID;
  658.   void* userInfo = NULL;
  659.   
  660.   name = databaseNames = type = elements = NULL;
  661.   dbList = elemList = NULL;
  662.   refID = NULL;
  663.  
  664.   /* read required part */
  665.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  666.   buf = readPDUType(&pduType,buf);
  667.   buf = readBinaryInteger(&small,(size_t)3,buf);
  668.   buf = readBinaryInteger(&large,(size_t)3,buf);
  669.   buf = readBinaryInteger(&medium,(size_t)3,buf);
  670.   buf = readBoolean(&replace,buf);
  671.   
  672.   /* read optional part */
  673.   while (buf < (buffer + size + HEADER_LEN)) 
  674.     { data_tag tag = peekTag(buf);
  675.       switch (tag)
  676.     { case DT_ResultSetName:
  677.         buf = readString(&name,buf);
  678.         break;
  679.       case DT_DatabaseNames:
  680.         {            /* parse the database names */
  681.           char *tok;
  682.           buf = readString(&databaseNames,buf);
  683.           tok = strtok(databaseNames,DB_DELIMITER);
  684.           numItems = 0;
  685.           while (tok != NULL)
  686.         { if (dbList == NULL)
  687.             dbList = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  688.         else
  689.           dbList = (char**)s_realloc((char*)dbList,(size_t)(sizeof(char*) * (numItems+2)));
  690.             dbList[numItems++] = s_strdup(tok);
  691.             dbList[numItems] = NULL;
  692.             tok = strtok(NULL,DB_DELIMITER);
  693.           }
  694.         }
  695.         break;
  696.       case DT_QueryType:
  697.         buf = readString(&type,buf);
  698.         break;
  699.       case DT_ElementSetNames:
  700.         {            /* parse the element set names */
  701.           char *tok;
  702.           buf = readString(&elements,buf);
  703.           if (elements[0] == ES_DELIMITER_1[0]) /* this is a single element w/ no db */
  704.         { elemList = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  705.           elemList[0] = s_strdup(elements);
  706.           elemList[1] = NULL;
  707.         }
  708.           else        /* its a group of <DB/ES> pairs */
  709.         { char* esTok = NULL;
  710.           tok = strtok(elements,ES_DELIMITER_1); /* db name */
  711.           esTok = strtok(NULL,ES_DELIMITER_2); /* es name */
  712.           numItems = 0;
  713.           while (tok != NULL)
  714.             { if (elemList == NULL)
  715.             elemList = (char**)s_malloc((size_t)(sizeof(char*) * 3));
  716.             else
  717.               elemList = (char**)s_realloc((char*)elemList,(size_t)(sizeof(char*) * (numItems * 2 + 1)));
  718.             elemList[numItems++] = s_strdup(tok);
  719.             elemList[numItems++] = s_strdup(esTok);
  720.             elemList[numItems] = NULL;
  721.             tok = strtok(NULL,ES_DELIMITER_1);
  722.             esTok = strtok(NULL,ES_DELIMITER_2);
  723.               } 
  724.         }
  725.         }
  726.         break;
  727.       case DT_ReferenceID:
  728.         buf = readAny(&refID,buf);
  729.         break;
  730.       default:
  731.         s_free(name);
  732.         s_free(type);
  733.         s_free(databaseNames);
  734.         doList((void**)dbList,fs_free);
  735.         s_free(dbList);
  736.         s_free(elements);
  737.         doList((void**)elemList,fs_free);
  738.         s_free(elemList);
  739.         freeAny(refID);
  740.         REPORT_READ_ERROR(buf);
  741.         break;
  742.       }
  743.     }
  744.   
  745.   buf = readSearchInfo(&userInfo,buf);
  746.   if (buf == NULL)
  747.     { s_free(name);
  748.       s_free(type);
  749.       s_free(databaseNames);
  750.       doList((void**)dbList,fs_free);
  751.       s_free(dbList);
  752.       s_free(elements);
  753.       doList((void**)elemList,fs_free);
  754.       s_free(elemList);
  755.       freeAny(refID);
  756.     }
  757.   RETURN_ON_NULL(buf);
  758.     
  759.   /* construct the search object */
  760.   *query = makeSearchAPDU(small,large,medium,replace,name,dbList,type,elemList,refID,userInfo);
  761.  
  762.   s_free(name);
  763.   s_free(type);
  764.   s_free(databaseNames);
  765.   doList((void**)dbList,fs_free);
  766.   s_free(dbList);
  767.   s_free(elements);
  768.   doList((void**)elemList,fs_free);
  769.   s_free(elemList);
  770.   freeAny(refID);
  771.   
  772.   return(buf);
  773. }
  774.  
  775. /*----------------------------------------------------------------------*/
  776.  
  777. SearchResponseAPDU* 
  778. makeSearchResponseAPDU(result,count,recordsReturned,nextPos,resultStatus,
  779.                presentStatus,refID,records)
  780. long result;
  781. long count;
  782. long recordsReturned;
  783. long nextPos;
  784. long resultStatus;
  785. long presentStatus;
  786. any* refID;
  787. void* records;
  788. {
  789.   SearchResponseAPDU* query = (SearchResponseAPDU*)s_malloc((size_t)sizeof(SearchResponseAPDU));
  790.   query->PDUType = searchResponseAPDU;
  791.   query->SearchStatus = result;
  792.   query->ResultCount = count;
  793.   query->NumberOfRecordsReturned = recordsReturned;
  794.   query->NextResultSetPosition = nextPos;
  795.   query->ResultSetStatus = resultStatus;
  796.   query->PresentStatus = presentStatus;
  797.   query->ReferenceID = duplicateAny(refID);
  798.   query->DatabaseDiagnosticRecords = records;
  799.   return(query);  
  800. }
  801.  
  802. /*----------------------------------------------------------------------*/
  803.  
  804. void 
  805. freeSearchResponseAPDU(queryResponse)
  806. SearchResponseAPDU* queryResponse;
  807. {
  808.   freeAny(queryResponse->ReferenceID);
  809.   s_free(queryResponse);
  810. }
  811.  
  812. /*----------------------------------------------------------------------*/
  813.  
  814. char* 
  815. writeSearchResponseAPDU(queryResponse,buffer,len)
  816. SearchResponseAPDU* queryResponse;
  817. char* buffer;
  818. long* len;
  819. {
  820.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  821.   long size;
  822.  
  823.   RESERVE_SPACE_FOR_HEADER(len);
  824.   
  825.   buf = writePDUType(queryResponse->PDUType,buf,len);
  826.   buf = writeBinaryInteger(queryResponse->SearchStatus,(size_t)1,buf,len);
  827.   buf = writeBinaryInteger(queryResponse->ResultCount,(size_t)3,buf,len);
  828.   buf = writeBinaryInteger(queryResponse->NumberOfRecordsReturned,(size_t)3,buf,len);
  829.   buf = writeBinaryInteger(queryResponse->NextResultSetPosition,(size_t)3,buf,len);
  830.   buf = writeNum(queryResponse->ResultSetStatus,DT_ResultSetStatus,buf,len);
  831.   buf = writeNum(queryResponse->PresentStatus,DT_PresentStatus,buf,len);
  832.   buf = writeAny(queryResponse->ReferenceID,DT_ReferenceID,buf,len);
  833.     
  834.   /* go back and write the header-length-indicator */
  835.   RELEASE_HEADER_SPACE(len);
  836.   size = buf - buffer - HEADER_LEN; 
  837.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  838.  
  839.   if (queryResponse->DatabaseDiagnosticRecords != NULL)
  840.     buf = writeSearchResponseInfo(queryResponse,buf,len);    
  841.     
  842.   return(buf);
  843. }
  844.  
  845. /*----------------------------------------------------------------------*/
  846.  
  847. char* 
  848. readSearchResponseAPDU(queryResponse,buffer)
  849. SearchResponseAPDU** queryResponse;
  850. char* buffer;
  851. {
  852.   char* buf = buffer;
  853.   long size;
  854.   pdu_type pduType;
  855.   long result,count,recordsReturned,nextPos;
  856.   long resultStatus,presentStatus;
  857.   any *refID = NULL;
  858.   void* userInfo = NULL;
  859.   
  860.   /* read required part */
  861.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  862.   buf = readPDUType(&pduType,buf);
  863.   buf = readBinaryInteger(&result,(size_t)1,buf);
  864.   buf = readBinaryInteger(&count,(size_t)3,buf);
  865.   buf = readBinaryInteger(&recordsReturned,(size_t)3,buf);
  866.   buf = readBinaryInteger(&nextPos,(size_t)3,buf);
  867.   
  868.   resultStatus = presentStatus = UNUSED;
  869.   refID = NULL;
  870.  
  871.   /* read optional part */
  872.   while (buf < (buffer + size + HEADER_LEN)) 
  873.     { data_tag tag = peekTag(buf);
  874.       switch (tag)
  875.     { case DT_ResultSetStatus:
  876.         buf = readNum(&resultStatus,buf);
  877.         break;
  878.       case DT_PresentStatus:
  879.         buf = readNum(&presentStatus,buf);
  880.         break;
  881.       case DT_ReferenceID:
  882.         buf = readAny(&refID,buf);
  883.         break;
  884.       default:
  885.         freeAny(refID);
  886.         REPORT_READ_ERROR(buf);
  887.         break;
  888.       }
  889.     }
  890.   
  891.   buf = readSearchResponseInfo(&userInfo,buf);
  892.   if (buf == NULL)
  893.     freeAny(refID);
  894.   RETURN_ON_NULL(buf);
  895.   
  896.   /* construct the search object */
  897.   *queryResponse = makeSearchResponseAPDU(result,count,recordsReturned,nextPos,
  898.                       (long)resultStatus,(long)presentStatus,refID,userInfo);
  899.  
  900.   freeAny(refID);
  901.   
  902.   return(buf);
  903. }
  904.  
  905. #ifdef NOTUSED
  906. /*----------------------------------------------------------------------*/
  907.  
  908.  
  909. PresentAPDU* 
  910. makePresentAPDU(recsReq,startPos,resultID,refID,info)
  911. long recsReq;
  912. long startPos;
  913. char* resultID;
  914. any* refID;
  915. void* info;
  916. {
  917.   PresentAPDU* present = (PresentAPDU*)s_malloc((size_t)sizeof(PresentAPDU));
  918.   present->PDUType = presentAPDU;
  919.   present->NumberOfRecordsRequested = recsReq;
  920.   present->ResultSetStartPosition = startPos;
  921.   present->ResultSetID = s_strdup(resultID);
  922.   present->ElementSetNames = NULL; /* XXX for now */
  923.   present->ReferenceID = duplicateAny(refID);
  924.   present->PresentInfo = info;
  925.   return(present);  
  926. }
  927.  
  928. /*----------------------------------------------------------------------*/
  929.  
  930. void 
  931. freePresentAPDU(present)
  932. PresentAPDU* present;
  933. {
  934.   /* handle element set names */ 
  935.   s_free(present->ResultSetID);
  936.   freeAny(present->ReferenceID);
  937.   s_free(present);
  938. }
  939.  
  940. /*----------------------------------------------------------------------*/
  941.  
  942. char* 
  943. writePresentAPDU(present,buffer,len)
  944. PresentAPDU* present;
  945. char* buffer;
  946. long* len;
  947. {
  948.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  949.   long size;
  950.  
  951.   RESERVE_SPACE_FOR_HEADER(len);
  952.   
  953.   buf = writePDUType(present->PDUType,buf,len);
  954.   buf = writeBinaryInteger(present->NumberOfRecordsRequested,(size_t)3,buf,len);
  955.   buf = writeBinaryInteger(present->ResultSetStartPosition,(size_t)3,buf,len);
  956.   buf = writeString(present->ResultSetID,DT_ResultSetID,buf,len); 
  957.   /* handle element set names */
  958.   buf = writeAny(present->ReferenceID,DT_ReferenceID,buf,len);
  959.     
  960.   /* go back and write the header-length-indicator */
  961.   RELEASE_HEADER_SPACE(len);
  962.   size = buf - buffer - HEADER_LEN; 
  963.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  964.  
  965.   if (present->PresentInfo != NULL)
  966.     buf = writePresentInfo(present,buf,len);   
  967.     
  968.   return(buf); 
  969. }
  970.  
  971. /*----------------------------------------------------------------------*/
  972.  
  973. char* 
  974. readPresentAPDU(present,buffer)
  975. PresentAPDU** present;
  976. char* buffer;
  977. {
  978.   char* buf = buffer;
  979.   long size;
  980.   pdu_type pduType;
  981.   long recsReq,startPos;
  982.   char* resultID = NULL;
  983.   any *refID = NULL;
  984.   void* userInfo = NULL;
  985.   
  986.   /* read required part */
  987.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  988.   buf = readPDUType(&pduType,buf);
  989.   buf = readBinaryInteger(&recsReq,(size_t)3,buf);
  990.   buf = readBinaryInteger(&startPos,(size_t)3,buf);
  991.   buf = readString(&resultID,buf);
  992.   
  993.   /* read optional part */
  994.   while (buf < (buffer + size + HEADER_LEN)) 
  995.    { data_tag tag = peekTag(buf);
  996.      switch (tag)
  997.       { case DT_ReferenceID:
  998.           buf = readAny(&refID,buf);
  999.           break;
  1000.         default:
  1001.           s_free(resultID);
  1002.           freeAny(refID);
  1003.           REPORT_READ_ERROR(buf);
  1004.           break;
  1005.       }
  1006.    }
  1007.   
  1008.   buf = readPresentInfo(&userInfo,buf);
  1009.   if (buf == NULL)
  1010.    { s_free(resultID);
  1011.      freeAny(refID);
  1012.    }
  1013.   RETURN_ON_NULL(buf);
  1014.  
  1015.   /* construct the present object */
  1016.   *present = makePresentAPDU(recsReq,startPos,resultID,refID,userInfo);
  1017.  
  1018.   s_free(resultID);
  1019.   freeAny(refID);
  1020.   
  1021.   return(buf);
  1022. }
  1023.  
  1024. /*----------------------------------------------------------------------*/
  1025.  
  1026.  
  1027. PresentResponseAPDU* 
  1028. makePresentResponseAPDU(status,recsRet,nextPos,refID,records)
  1029. boolean status;
  1030. long recsRet;
  1031. long nextPos;
  1032. any* refID;
  1033. void* records;
  1034. {
  1035.   PresentResponseAPDU* present = (PresentResponseAPDU*)s_malloc((size_t)sizeof(PresentResponseAPDU));
  1036.   present->PDUType = presentResponseAPDU;
  1037.   present->PresentStatus = status;
  1038.   present->NumberOfRecordsReturned = recsRet;
  1039.   present->NextResultSetPosition = nextPos;
  1040.   present->ReferenceID = duplicateAny(refID);
  1041.   present->DatabaseDiagnosticRecords = records;
  1042.   return(present);  
  1043. }
  1044.  
  1045. /*----------------------------------------------------------------------*/
  1046.  
  1047. void 
  1048. freePresentResponseAPDU(present)
  1049. PresentResponseAPDU* present;
  1050. { 
  1051.   freeAny(present->ReferenceID);
  1052.   s_free(present);
  1053. }
  1054.  
  1055. /*----------------------------------------------------------------------*/
  1056.  
  1057. char* 
  1058. writePresentResponseAPDU(present,buffer,len)
  1059. PresentResponseAPDU* present;
  1060. char* buffer;
  1061. long* len;
  1062. {
  1063.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  1064.   long size;
  1065.  
  1066.   RESERVE_SPACE_FOR_HEADER(len);
  1067.   
  1068.   buf = writePDUType(present->PDUType,buf,len);
  1069.   buf = writeBoolean(present->PresentStatus,buf,len);
  1070.   buf = writeBinaryInteger(present->NumberOfRecordsReturned,(size_t)3,buf,len);
  1071.   buf = writeBinaryInteger(present->NextResultSetPosition,(size_t)3,buf,len);
  1072.   buf = writeAny(present->ReferenceID,DT_ReferenceID,buf,len);
  1073.     
  1074.   /* go back and write the header-length-indicator */
  1075.   RELEASE_HEADER_SPACE(len);
  1076.   size = buf - buffer - HEADER_LEN; 
  1077.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  1078.  
  1079.   if (present->DatabaseDiagnosticRecords != NULL)
  1080.     buf = writePresentResponseInfo(present,buf,len);
  1081.     
  1082.   return(buf);
  1083. }
  1084.  
  1085. /*----------------------------------------------------------------------*/
  1086.  
  1087. char* 
  1088. readPresentResponseAPDU(present,buffer)
  1089. PresentResponseAPDU** present;
  1090. char* buffer;
  1091. {
  1092.   char* buf = buffer;
  1093.   long size;
  1094.   pdu_type pduType;
  1095.   boolean status;
  1096.   long recsRet,nextPos;
  1097.   any *refID = NULL;
  1098.   void* userInfo = NULL;
  1099.  
  1100.   /* read required part */
  1101.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  1102.   buf = readPDUType(&pduType,buf);
  1103.   buf = readBoolean(&status,buf);
  1104.   buf = readBinaryInteger(&recsRet,(size_t)3,buf);
  1105.   buf = readBinaryInteger(&nextPos,(size_t)3,buf);
  1106.  
  1107.   /* read optional part */
  1108.   while (buf < (buffer + size + HEADER_LEN)) 
  1109.    { data_tag tag = peekTag(buf);
  1110.      switch (tag)
  1111.       { case DT_ReferenceID:
  1112.           buf = readAny(&refID,buf);
  1113.           break;
  1114.         default:
  1115.           freeAny(refID);
  1116.           REPORT_READ_ERROR(buf);
  1117.           break;
  1118.       }
  1119.    }
  1120.   
  1121.   buf = readPresentResponseInfo(&userInfo,buf);
  1122.   if (buf == NULL)
  1123.     freeAny(refID);
  1124.   RETURN_ON_NULL(buf);
  1125.  
  1126.   /* construct the presentResponse object */
  1127.   *present = makePresentResponseAPDU(status,recsRet,nextPos,refID,userInfo);
  1128.  
  1129.   freeAny(refID);
  1130.   
  1131.   return(buf);
  1132. }
  1133.  
  1134. /*----------------------------------------------------------------------*/
  1135.  
  1136.  
  1137. #endif /* def NOTUSED */
  1138.